
#ifndef __CAMINOBACKTRACKING_H__
#define __CAMINOBACKTRACKING_H__

#include <iostream>
#include <stack>
#include "PosicionBackTracking.h"

class CaminoBackTracking{

	private:
		std::stack<PosicionBackTracking*>* camino;

	public:
		CaminoBackTracking(){
			
			this->camino = new std::stack<PosicionBackTracking*>();
		}

		void agregarPosicionAlCamino(PosicionBackTracking* posicion){

			this->camino->push(posicion);
		}

		PosicionBackTracking* getUltimaPosicionDelCamino(){
			PosicionBackTracking* posicion = 0;
			if(this->camino){
				posicion = this->camino->top();
				this->camino->pop();
			}
			return posicion;
		}

		CaminoBackTracking* copiarCamino(){
			
			CaminoBackTracking* copiaDeCaminoInvertido = new CaminoBackTracking();
			CaminoBackTracking* copiaDeCamino = new CaminoBackTracking();
			
			
			while(!this->camino->empty()){

				PosicionBackTracking* posicionInvertida = this->camino->top();
				copiaDeCaminoInvertido->agregarPosicionAlCamino(posicionInvertida);
				this->camino->pop();
			}

			while(!copiaDeCaminoInvertido->getPilaDePosiciones()->empty()){

				PosicionBackTracking* posicionInvertida = copiaDeCaminoInvertido->getPilaDePosiciones()->top();
				PosicionBackTracking* copiaDePosicion = new PosicionBackTracking(posicionInvertida); 
				this->camino->push(posicionInvertida);
				copiaDeCamino->getPilaDePosiciones()->push(copiaDePosicion);
				copiaDeCaminoInvertido->getPilaDePosiciones()->pop();
			}

			delete copiaDeCaminoInvertido;

			return copiaDeCamino;
		}

		std::stack<PosicionBackTracking*>* getPilaDePosiciones(){

			return this->camino;
		}

		int getLargoDelCamino(){
			
			if(this->camino->empty()){

				return 0;
			}else{

				return (int)this->camino->size();
			}
			
		}

		bool perteneceAlCamino(PosicionBackTracking* posicion){
			
			CaminoBackTracking* caminoAux = this->copiarCamino();
			bool encontrado = false;

			while(caminoAux->getLargoDelCamino() != 0 && !encontrado){
				
				PosicionBackTracking* posicionAux = caminoAux->getUltimaPosicionDelCamino();
				if((posicionAux->getFila() == posicion->getFila()) && (posicionAux->getColumna() == posicion->getColumna())){
					encontrado = true;
				}
				delete posicionAux;
			}

			delete caminoAux;
			return encontrado;
		}

		~CaminoBackTracking(){
			
			while(!this->camino->empty()){
				//PosicionBackTracking* posicion = this->camino->top();
				
				delete this->camino->top();
				this->camino->pop();
				//delete posicion ;
			}

			delete this->camino;
		}
};

#endif